#include <iostream>
using namespace std;
class Line{
   public:
      int getLength( void );
      Line( int len );            
      Line( const Line &obj);     
      ~Line();                  
   private:
      int *ptr;
};
Line::Line(int len){
    cout << "调用构造函数" << endl;
    ptr = new int;
    *ptr = len; //将len放入指针ptr指向的内存空间 
}
Line::Line(const Line &obj){
    cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;
    ptr = new int;
    *ptr = *obj.ptr; 
}
Line::~Line(){
    cout << "释放内存" << endl;
    delete ptr;
}
int Line::getLength(  ){
    return *ptr;
}
void display(Line obj)//display函数要求一个类类型的参数，然后将之前定义的参数line传递进去，注意，在传递进去的过程会发生形参到实参的复制，此时会调用拷贝构造函数, 
{
   cout << "line 大小 : " << obj.getLength() <<endl;//在执行display函数体的时候,调用getlength函数输出line大小
}
int main0( ){
	Line line(10);
	display(line);//调用display函数 
	return 0;//这之后程序会进行析构，第一个析构，是display函数里面的形参,对于display函数中的obj来说，作用范围仅仅在display函数内部,出display函数后肯定进行析构 
}//第二个析构是int main（）中定义的line对象的析构


class A
{
	public:
	int v;
	A(int n)
	{
		v=n;
	 } ;
	 A(const A & a)//定义了复制构造函数 
	 {
	 	v=a.v;
	 	cout<<"复制构造函数"; 
	  } 
 } ;
A fun()//表示fun()函数的返回值是类A的对象
//根据c++的规定一个函数的返回值如果是对象，这个对象用复制构造函数初始化 
{
	A b(4);
	return b; 
 } 
int main2()
{
	cout<<fun().v<<endl;
	return 0;
 }

#include<iostream>
using namespace std;
class point
{		int x,y;
	public:
		point(int a=0,int b=0){x=a;y=b;cout<<"调用构造函数"<<endl;}
		point(point &p);
		int getx(){return x;}
		int gety(){return y;}
		~point(){cout<<"析构"<<endl;}
};
point::point(point &p)
{
	x=p.x+10;  y=p.y+20;
	cout<<"调用复制构造函数"<<endl;
}
void f(point p)
{
   cout<<p.getx()<<" "<<p.gety()<<endl;
   }
point g()
{
  point q(3,5);
  return q;
}

point func() {  
     point obj(10);    // 调用带参数的构造函数创建对象  
     return obj;         // 返回对象，触发复制构造函数  
} 
int main(){
	point p1(1.1,2.2);//定义了一个对象p1同时调用构造函数 

	point p2(p1);//用p1初始化p2,要调用复制构造函数 
	cout<<p2.getx()<<" "<<p2.gety()<<endl;

	f(p2);//调用函数f()，f()函数的参数是类类型的,实参到形参的传递会调用拷贝构造函数,紧接着执行函数体,输出p.getx()，p.gety() ，当函数f()结束时，参数p是局部对象
	//它要进行析构 
	p2=g();//调用g()函数,g()函数返回的是一个类类型,在这个过程中会调用拷贝构造函数(从结果中并没有看出它调用了拷贝构造函数),当执行g()的函数体的时候，创建一个q，并且把q返回,在这个过程中会产生临时对象,
	//当g()函数结束的时候,会调用析构函数,清理调它 
	cout<<p2.getx()<<" "<<p2.gety()<<endl;
	point p3;//定义了一个对象p1同时调用构造函数 
    p3 = func();
}